home *** CD-ROM | disk | FTP | other *** search
/ Developer CD Series 1999 …ember: Reference Library / Apple Developer Reference Library (December 1999) (Disk 1).iso / pc / what's new / sample code / graphics 2d / new newgworld / new newgworld.c < prev    next >
Encoding:
Text File  |  1999-10-24  |  17.8 KB  |  645 lines
  1. /*
  2.     File:        New NewGWorld.c
  3.  
  4.     Contains:    Sample application demonstrating the use of the new version of the NewGWorld routine
  5.  
  6.     Written by:    Geoff Stahl (ggs)
  7.  
  8.     Copyright:    Copyright (c) 1999 Apple Computer, Inc., All Rights Reserved.
  9.  
  10.                 You may incorporate this Apple sample source code into your program(s) without
  11.                 restriction. This Apple sample source code has been provided "AS IS" and the
  12.                 responsibility for its operation is yours. You are not permitted to redistribute
  13.                 this Apple sample source code as "Apple sample source code" after having made
  14.                 changes. If you're going to re-distribute the source, we require that you make
  15.                 it clear in the source that the code was descended from Apple sample source
  16.                 code, but that you've made changes.
  17.  
  18. */
  19.   
  20. // system includes ----------------------------------------------------------
  21.  
  22. #include <MacMemory.h>
  23. #include <Events.h>
  24. #include <Fonts.h>
  25. #include <Windows.h>
  26. #include <TextEdit.h>
  27. #include <Dialogs.h>
  28. #include <Devices.h>
  29. #include <Sound.h>
  30. #include <SoundInput.h>
  31. #include <ToolUtils.h>
  32. #include <OSUtils.h>
  33. #include <LowMem.h>
  34. #include <Gestalt.h>
  35.  
  36. #include <stdlib.h>
  37.  
  38. // project includes ---------------------------------------------------------
  39.  
  40.  
  41.  
  42. // statics/globals (internal only) ------------------------------------------
  43.  
  44. // Menu defs
  45. enum 
  46. {
  47.     kMenuApple = 128,
  48.     kMenuFile = 129,
  49.     
  50.     kAppleAbout = 1,    
  51.     kFileInVRAM = 1,                        // allocate buffer in VRAM
  52.     kFileInAGP,                                // allocate buffer in AGP memory
  53.     kFileInSystem,                            // allocate buffer in system memory
  54.     kFileTest,                                // run blitting test
  55.     kFileQuit                                // quit
  56. };
  57.  
  58. enum
  59. {
  60.                                             // Initial Window Constants
  61.     kWindowHeight = 400,                    //   "
  62.     kWindowWidth = 500,                        //   "
  63.     kWindowOffset = 100                        //   "
  64. };
  65.  
  66. enum
  67. {
  68.     kNoWhere = 0,                            // where is the off screen
  69.     kInVRAM,
  70.     kInAGP,
  71.     kInSystem
  72. };
  73.  
  74. Boolean gDone = false;                        // is app done
  75. SInt32 gSleepTime = 60;                        // yield time
  76.  
  77. WindowPtr gpWindow = NULL;                    // main window
  78. GWorldPtr gpGWOffScreen = NULL;                // main window offscreen scratch
  79. short gwLocOffscreen = 0;                    // curretn offscreen location
  80.  
  81. Boolean gNewNewGWorld = false;                // can we allocate in VRAm or AGP memory?
  82.  
  83.  
  84. // functions Prototypes (internal/private) -----------------------------------
  85.  
  86. // returns GDHandle that window resides on (most of it anyway)
  87. GDHandle GetWindowDevice (WindowPtr pWindow);
  88. // checks and allocates (if required) a new GWorld size of pWindow in memory type target; returns true if (re)allocated
  89. Boolean BuildOffscreen (GWorldPtr * ppGWorld, WindowPtr pWindow, short * target);
  90. // fills offscreen buffer with random bright color
  91. void FillOffscreen (GWorldPtr pGWorld);
  92. // checks offscreen and blits it to the front
  93. void BlitToWindow (GWorldPtr pGWorld, WindowPtr pWindow, short * pLocation);
  94. // checks buffer and then runs 200 iteration CopyBits test offscreen to on and reprots results
  95. void RunTest (void);
  96. // Forces offscreen allocation (if different than current) in memory type specified and sets menu flag
  97. void AllocBuffer (short target);
  98.  
  99. // standard stuff
  100. void InitToolbox(void);                                                    // standard inits
  101. Boolean SetUp (void);                                                    // application setup
  102. void DoMenu (SInt32 menuResult);                                        // menu event handler
  103. void DoKey (SInt8 theKey, SInt8 theCode);                                // key down handling
  104. void DoUpdate (WindowPtr pWindow);                                        // draw from off screen to on and updates control postions on screen for events
  105. void DoEvent (void);                                                    // event handler
  106. void CleanUp (void);                                                    // clean ups after application
  107.  
  108. // functions (internal/private) ---------------------------------------------
  109.  
  110. // returns GDHandle that window resides on (most of it anyway)
  111.  
  112. GDHandle GetWindowDevice (WindowPtr pWindow)
  113. {
  114.     GrafPtr pgpSave;
  115.     Rect rectWind, rectSect;
  116.     long greatestArea, sectArea;
  117.     GDHandle hgdNthDevice, hgdZoomOnThisDevice;
  118.     GetPort (&pgpSave);
  119.     SetPort (pWindow);
  120.     rectWind = pWindow->portRect;
  121.     LocalToGlobal ((Point*)& rectWind.top);    // convert to global coordinates
  122.     LocalToGlobal ((Point*)& rectWind.bottom);
  123.     hgdNthDevice = GetDeviceList ();
  124.     greatestArea = 0;     // initialize to 0
  125.     // check window against all gdRects in gDevice list and remember 
  126.     //  which gdRect contains largest area of window}
  127.     while (hgdNthDevice)
  128.     {
  129.         if (TestDeviceAttribute (hgdNthDevice, screenDevice))
  130.             if (TestDeviceAttribute (hgdNthDevice, screenActive))
  131.             {
  132.                 // The SectRect routine calculates the intersection 
  133.                 //  of the window rectangle and this gDevice 
  134.                 //  rectangle and returns TRUE if the rectangles intersect, 
  135.                 //  FALSE if they don't.
  136.                 SectRect(&rectWind, &(**hgdNthDevice).gdRect, &rectSect);
  137.                 // determine which screen holds greatest window area
  138.                 //  first, calculate area of rectangle on current device
  139.                 sectArea = (long)(rectSect.right - rectSect.left) * (rectSect.bottom - rectSect.top);
  140.                 if ( sectArea > greatestArea )
  141.                 {
  142.                     greatestArea = sectArea;    // set greatest area so far
  143.                     hgdZoomOnThisDevice = hgdNthDevice;    // set zoom device
  144.                 }
  145.                 hgdNthDevice = GetNextDevice(hgdNthDevice);
  146.             }
  147.     }     // of WHILE
  148.     SetPort (pgpSave);
  149.     return hgdZoomOnThisDevice;
  150. }
  151.  
  152. // --------------------------------------------------------------------------
  153.  
  154. // checks and allocates (if required) a new GWorld size of pWindow in memory type target; returns true if (re)allocated
  155. // Currently, this routine checks to see if the GWorld is NULL, the PixMap is NULL, the baseAddr is NULL, the GDevice of the PixMap
  156. //   and the window do not match, and if the color depths are not the same.  If any of the previous is true the GWorld is re-allocated.
  157.  
  158. Boolean BuildOffscreen (GWorldPtr * ppGWorld, WindowPtr pWindow, short * location)
  159. { 
  160.     GDHandle hgdWindow = GetWindowDevice (pWindow);    // window GDevice
  161.     short wPixDepth = (**((CGrafPtr)pWindow)->portPixMap).pixelSize; // window pixel depth
  162.     Boolean fMustRebuild = false;
  163.     
  164.     if (NULL == *ppGWorld) // if GWorld passed in is not allocated
  165.         fMustRebuild = true;
  166.     else
  167.     {
  168.         PixMapHandle hPixmap = GetGWorldPixMap (*ppGWorld);
  169.         if ((NULL == hPixmap) || (NULL == GetPixBaseAddr (hPixmap))) // if pixmap handle is NULL or pixmap base address is NULL
  170.             fMustRebuild = true;
  171.         else if (GetGWorldDevice(*ppGWorld) != hgdWindow) // if GWorld not on same device as window
  172.             fMustRebuild = true;
  173.         else if ((**hPixmap).pixelSize != wPixDepth) // if color depths are not the same
  174.             fMustRebuild = true;
  175.     }
  176.     
  177.     if (fMustRebuild) // must rebuild
  178.     {    
  179.         if (NULL != *ppGWorld) // if we have an allocated GWorld
  180.         {
  181.             DisposeGWorld (*ppGWorld);    // dump our current GWorld
  182.             *ppGWorld = NULL;
  183.         }
  184.         switch (*location) // where to we want to put it
  185.         {
  186.             case kInVRAM:
  187.                 if (noErr == NewGWorld (ppGWorld, wPixDepth, &pWindow->portRect, NULL, hgdWindow, noNewDevice | useDistantHdwrMem))                
  188.                     break;
  189.                 // we failed with VRAM, signal that and drop to AGP
  190.                 SysBeep (30);
  191.                 *location = kInAGP;
  192.             case kInAGP:
  193.                 if (noErr == NewGWorld (ppGWorld, wPixDepth, &pWindow->portRect, NULL, hgdWindow, noNewDevice | useLocalHdwrMem))
  194.                     break;
  195.                 // we failed with AGP, signal that and drop to system memory
  196.                 SysBeep (30);
  197.                 *location = kInSystem;
  198.             case kInSystem:
  199.             default:
  200.                 if (noErr != NewGWorld (ppGWorld, wPixDepth, &pWindow->portRect, NULL, hgdWindow, noNewDevice | keepLocal))
  201.                 {
  202.                     // we failed with system thus we can't allocate our GWorld, signal that, indicate no location and drop to debugger
  203.                     SysBeep (30);
  204.                     *location = kNoWhere;
  205.                     DebugStr ("\pUnable to allocate off screen image");
  206.                     return false; // nothing was allocated
  207.                 }
  208.         } 
  209.         return true; // we rebuilt our GWorld
  210.     }
  211.     return false; // everything is okay
  212. }
  213.  
  214. // --------------------------------------------------------------------------
  215.  
  216. // fills offscreen buffer with random bright color
  217.  
  218. void FillOffscreen (GWorldPtr pGWorld)
  219. {
  220.     static RGBColor rgbColorOld;
  221.     GDHandle hGDSave;
  222.     CGrafPtr pCGrafSave;
  223.     Rect rectSource = (pGWorld->portRect);
  224.     RGBColor rgbColor;
  225.     
  226.     do 
  227.         rgbColor.red = (Random () + 32767) / 2 + 32767;
  228.     while (abs (rgbColor.red - rgbColorOld.red) <  3000);    
  229.     do 
  230.         rgbColor.green = (Random () + 32767) / 2 + 32767;
  231.     while (abs (rgbColor.green - rgbColorOld.green) <  3000);
  232.     do 
  233.         rgbColor.blue = (Random () + 32767) / 2 + 32767;
  234.     while (abs (rgbColor.blue - rgbColorOld.blue) <  3000);
  235.     
  236.     rgbColorOld = rgbColor;
  237.  
  238.     GetGWorld (&pCGrafSave, &hGDSave);
  239.     SetGWorld (pGWorld, NULL);
  240.     if (LockPixels (GetGWorldPixMap (pGWorld)))
  241.     {
  242.         // draw some background
  243.         EraseRect (&rectSource);
  244.         RGBForeColor (&rgbColor);
  245.         PaintRect (&rectSource);
  246.         UnlockPixels (GetGWorldPixMap (pGWorld));
  247.     }
  248.     SetGWorld (pCGrafSave, hGDSave);
  249. }
  250.  
  251. // --------------------------------------------------------------------------
  252.  
  253. // checks offscreen and blits it to the front
  254.  
  255. void BlitToWindow (GWorldPtr pGWorld, WindowPtr pWindow, short * pLocation)
  256. {
  257.     Rect rectDest = ((GrafPtr)pWindow)->portRect;
  258.     Rect rectSource = ((GrafPtr)pWindow)->portRect;
  259.     GrafPtr pCGrafSave;
  260.     
  261.     // check to ensure we have a valid offscreen and rebuild if required
  262.     if (BuildOffscreen (&pGWorld, pWindow, pLocation))
  263.         FillOffscreen (pGWorld);
  264.     
  265.     // blit
  266.     GetPort (&pCGrafSave);
  267.     SetPort ((GrafPtr) pWindow);
  268.     if (LockPixels (GetGWorldPixMap (pGWorld)))
  269.     {
  270.         CopyBits (&((GrafPtr)pGWorld)->portBits, &pWindow->portBits, &rectSource, &rectDest, srcCopy, NULL);
  271.         UnlockPixels (GetGWorldPixMap (pGWorld));
  272.     }
  273.     else
  274.         SysBeep (30);
  275.     SetPort (pCGrafSave);
  276. }
  277.  
  278. // --------------------------------------------------------------------------
  279.  
  280. // checks buffer and then runs 200 iteration CopyBits test offscreen to on and reprots results
  281.  
  282. void RunTest (void)
  283. {
  284.     Str255 str = "\p";
  285.     Rect rectDest = ((GrafPtr)gpWindow)->portRect;
  286.     Rect rectSource = ((GrafPtr)gpWindow)->portRect;
  287.     GrafPtr pCGrafSave;
  288.     long time;
  289.     short i;
  290.  
  291.     BlitToWindow (gpGWOffScreen, gpWindow, &gwLocOffscreen);
  292.  
  293.     GetPort (&pCGrafSave);
  294.     SetPort ((GrafPtr) gpWindow);
  295.     if (LockPixels (GetGWorldPixMap (gpGWOffScreen)))
  296.     {
  297.         time = TickCount ();
  298.         for (i = 0; i < 200; i++)
  299.             CopyBits (&((GrafPtr)gpGWOffScreen)->portBits, &gpWindow->portBits, &rectSource, &rectDest, srcCopy, NULL);
  300.         time = TickCount () - time;
  301.         time = 200 * 60 / time;
  302.  
  303.         NumToString (rectSource.right - rectSource.left, str);
  304.         MoveTo (10, 20);
  305.         DrawString (str);
  306.         MoveTo (43, 20);
  307.         DrawString ("\px");
  308.         NumToString (rectSource.bottom - rectSource.top, str);
  309.         MoveTo (56, 20);
  310.         DrawString (str);
  311.         NumToString (time, str);
  312.         MoveTo (10, 35);
  313.         DrawString (str);
  314.         MoveTo (48, 35);
  315.         DrawString ("\pfps");
  316.         MoveTo (10, 50);
  317.         switch (gwLocOffscreen)
  318.         {
  319.             case kInVRAM:
  320.                 DrawString ("\pIn VRAM");
  321.                 break;
  322.             case kInAGP:
  323.                 DrawString ("\pIn AGP memory");
  324.                 break;
  325.             case kInSystem:
  326.                 DrawString ("\pIn system memory");
  327.                 break;
  328.             default:
  329.                 break;
  330.         }
  331.         UnlockPixels (GetGWorldPixMap (gpGWOffScreen));
  332.     }
  333.     else
  334.     {
  335.         SysBeep (30);
  336.         MoveTo (10, 20);
  337.         DrawString ("\pBlit test failed.");
  338.     }
  339.     SetPort (pCGrafSave);
  340. }
  341.  
  342. // --------------------------------------------------------------------------
  343.  
  344. // forces offscreen allocation (if different than current) in memory type specified and sets menu flag
  345.  
  346. void AllocBuffer (short location)
  347. {
  348.     MenuHandle hMenu;
  349.     short i;
  350.     
  351.     // check to see if we are allocated in the desired buffer
  352.     if (location != gwLocOffscreen) 
  353.     { 
  354.         // dispose to force a rebuild
  355.         if (gpGWOffScreen)
  356.             DisposeGWorld (gpGWOffScreen);
  357.         gpGWOffScreen = NULL;
  358.         gwLocOffscreen = location;
  359.     }
  360.     // ensure we are properly built
  361.     if (BuildOffscreen (&gpGWOffScreen, gpWindow, &gwLocOffscreen))
  362.     {
  363.         FillOffscreen (gpGWOffScreen);
  364.         BlitToWindow (gpGWOffScreen, gpWindow, &gwLocOffscreen);
  365.     }
  366.     
  367.     // set menus
  368.     hMenu = GetMenuHandle (kMenuFile);
  369.     for (i = kFileInVRAM; i <= kFileInSystem; i++)
  370.         CheckMenuItem (hMenu, i, false);
  371.     CheckMenuItem (hMenu, gwLocOffscreen, true);
  372. }
  373.  
  374. // --------------------------------------------------------------------------
  375.  
  376. void InitToolbox()
  377. {
  378.     MenuHandle menu;
  379.  
  380.     MaxApplZone ();
  381.  
  382.     InitGraf((Ptr) &qd.thePort);
  383.     InitFonts();
  384.     InitWindows();
  385.     InitMenus();
  386.     TEInit();
  387.     InitDialogs(nil);
  388.     InitCursor();
  389.     
  390.     qd.randSeed =  TickCount();
  391.  
  392.     // Init Menus
  393.     menu = NewMenu (kMenuApple, "\p\024");            // new  apple menu
  394.     InsertMenu (menu, 0);                            // add menu to end
  395.     AppendResMenu(menu, 'DRVR');
  396.     
  397.     menu = NewMenu (kMenuFile, "\pFile");            // new menu
  398.     InsertMenu (menu, 0);                            // add menu to end
  399.     AppendMenu (menu, "\pAllocate In VRAM;Allocate In AGP Memory;Allocate In System Memory;Run Blit Test;Quit/Q");         // add items
  400.     
  401.     DrawMenuBar();
  402. } 
  403.  
  404. // --------------------------------------------------------------------------
  405.  
  406. Boolean SetUp (void)
  407. {
  408.     Rect rectWindow;
  409.     MenuHandle hMenu;
  410.     long versionSystem;
  411.     short i;
  412.     
  413.     InitToolbox ();
  414.  
  415.     SetRect (&rectWindow, 0, 0, kWindowWidth, kWindowHeight);
  416.     OffsetRect (&rectWindow, kWindowOffset, kWindowOffset);
  417.     gpWindow = NewCWindow (NULL, &rectWindow, "\pNew NewGWorld Test", true, kWindowGrowDocumentProc, (WindowPtr) -1, false, 0);
  418.  
  419.     gNewNewGWorld = false;
  420.     // this will work 9.x
  421.     Gestalt (gestaltSystemVersion, &versionSystem);
  422.     if (0x00000900 == (versionSystem & 0x00000FF00))
  423.         gNewNewGWorld = true;
  424.     else
  425.     {
  426.         // now it is tricky
  427.         // we will try to allocate in VRAM and find out where the allocation really ended up.
  428.         GWorldPtr pgwTest = NULL;
  429.         Rect rectTest = {0, 0, 10, 10};
  430.         short wPixDepth = (**((CGrafPtr)gpWindow)->portPixMap).pixelSize; // window pixel depth
  431.         GDHandle hgdWindow = GetWindowDevice (gpWindow);    // window GDevice
  432.         if ((noErr == NewGWorld (&pgwTest, wPixDepth, &rectTest, NULL, hgdWindow, noNewDevice | useDistantHdwrMem)) &&
  433.             (pgwTest) && // if we had a good allocation
  434.             (GetZone () != HandleZone ((Handle)((**pgwTest->portPixMap).baseAddr)))) // if we did not allocate in our zone
  435.             gNewNewGWorld = true;    
  436.         if (pgwTest)
  437.             DisposeGWorld (pgwTest);
  438.     }        
  439.     if (!gNewNewGWorld)
  440.     {
  441.         hMenu = GetMenuHandle (kMenuFile);
  442.         for (i = kFileInVRAM; i <= kFileInAGP; i++)
  443.              DisableItem (hMenu, i);
  444.         AllocBuffer (kInSystem);
  445.     }
  446.     else
  447.         AllocBuffer (kInVRAM);
  448.     return true;
  449. }
  450.  
  451. // --------------------------------------------------------------------------
  452.  
  453. void DoMenu (SInt32 menuResult)
  454. {
  455.     SInt16 theMenu;
  456.     SInt16 theItem;
  457.     Str255 daName;
  458.     MenuRef theMenuHandle;
  459.         
  460.     theMenu = HiWord(menuResult);
  461.     theItem = LoWord(menuResult);
  462.     theMenuHandle = GetMenuHandle(theMenu);
  463.  
  464.     switch (theMenu)
  465.     {
  466.         case kMenuApple:
  467.             switch (theItem)
  468.             {
  469.                 case kAppleAbout:
  470.                     break;
  471.                 default:
  472.                     OpenDeskAcc(daName);
  473.                     break;
  474.             }
  475.             break;
  476.         case kMenuFile:
  477.             switch (theItem)
  478.             {
  479.                 case kFileInVRAM:
  480.                     AllocBuffer (kInVRAM);
  481.                     break;
  482.                 case kFileInAGP:
  483.                     AllocBuffer (kInAGP);
  484.                     break;
  485.                 case kFileInSystem:
  486.                     AllocBuffer (kInSystem);
  487.                     break;
  488.                 case kFileTest:
  489.                     RunTest ();
  490.                     break;
  491.                 case kFileQuit:
  492.                     gDone = true;
  493.                     break;
  494.             }
  495.             break;
  496.     }
  497.     HiliteMenu(0);
  498.     DrawMenuBar();
  499. }
  500.  
  501. // --------------------------------------------------------------------------
  502.  
  503. void DoKey (SInt8 theKey, SInt8 theCode)
  504. {
  505.     #pragma unused (theKey, theCode)
  506. }
  507.  
  508. // --------------------------------------------------------------------------
  509.  
  510. void DoUpdate (WindowPtr pWindow)
  511. {
  512.     BlitToWindow (gpGWOffScreen, pWindow, &gwLocOffscreen);
  513. }
  514.  
  515. // --------------------------------------------------------------------------
  516.  
  517. void DoEvent (void)
  518. {
  519.     EventRecord theEvent;
  520.     Rect rectGrow;
  521.     WindowRef whichWindow;
  522.     long grow;
  523.     SInt32 menuResult;
  524.     SInt16 whatPart;
  525.     SInt8 theKey;
  526.     SInt8 theCode;
  527.     
  528.     if (WaitNextEvent(everyEvent, &theEvent, gSleepTime, NULL))
  529.     {
  530.         switch (theEvent.what)
  531.         {
  532.             case mouseDown:
  533.                 whatPart = FindWindow(theEvent.where, &whichWindow);
  534.                 switch (whatPart)
  535.                 {
  536.                     case inGoAway:
  537.                         break;
  538.                     case inMenuBar:
  539.                         DrawMenuBar();
  540.                         menuResult = MenuSelect(theEvent.where);
  541.                         if (HiWord(menuResult) != 0)
  542.                             DoMenu(menuResult);
  543.                         break;
  544.                     case inDrag:
  545.                         DragWindow (whichWindow, theEvent.where, &(**LMGetGrayRgn()).rgnBBox);
  546.                         // ensure we are properly built
  547.                         if (BuildOffscreen (&gpGWOffScreen, gpWindow, &gwLocOffscreen))
  548.                         {
  549.                             FillOffscreen (gpGWOffScreen);
  550.                             BlitToWindow (gpGWOffScreen, gpWindow, &gwLocOffscreen);
  551.                         }
  552.                         break;
  553.                     case inGrow:
  554.                         SetRect (&rectGrow, 100, 100, 20000, 20000);
  555.                         grow = GrowWindow (whichWindow, theEvent.where, &rectGrow);
  556.                         if (grow)
  557.                         {
  558.                             SizeWindow (whichWindow, grow & 0x0000FFFF, grow >> 16, true);
  559.                             // ensure offscreen buffer is reallocated
  560.                             if (gpGWOffScreen)
  561.                                 DisposeGWorld (gpGWOffScreen);
  562.                             gpGWOffScreen = NULL;
  563.                             AllocBuffer (gwLocOffscreen);
  564.                             SetPort (whichWindow);
  565.                             InvalRect (&whichWindow->portRect);                // redraw all
  566.                         }
  567.                         break;
  568.                     case inSysWindow:
  569.                         SystemClick(&theEvent, whichWindow);
  570.                         break;
  571.                 }
  572.                 break;
  573.             case keyDown:
  574.             case autoKey:
  575.                 theKey = theEvent.message & charCodeMask;
  576.                 theCode = (theEvent.message & keyCodeMask) >> 8;
  577.                 if ((theEvent.modifiers & cmdKey) != 0)
  578.                 {
  579.                     menuResult = MenuKey(theKey);
  580.                     if (HiWord(menuResult) != 0)
  581.                         DoMenu (menuResult);
  582.                 }
  583.                 else
  584.                     DoKey (theKey, theCode);
  585.                 break;
  586.             case updateEvt:
  587.                 BeginUpdate((WindowPtr) theEvent.message);
  588.                 DoUpdate((WindowPtr) theEvent.message);
  589.                 EndUpdate((WindowPtr) theEvent.message);
  590.                 break;
  591.             case diskEvt:
  592.                 break;
  593.             case osEvt:
  594.                 break;
  595.  
  596.             case kHighLevelEvent:
  597.                 AEProcessAppleEvent(&theEvent);
  598.                 break;
  599.         }
  600.     }
  601.     else
  602.     {
  603.         // idle tasks
  604.     }
  605. }
  606.  
  607. // --------------------------------------------------------------------------
  608.  
  609. void CleanUp (void)
  610. {
  611.     MenuHandle hMenu;
  612.  
  613.     HideWindow (gpWindow);
  614.     if (gpWindow)
  615.         DisposeWindow (gpWindow);
  616.     gpWindow = NULL;
  617.     
  618.     // this is VERY important since the GWorld may not be in the application heap zone
  619.     // leaked memory here outside the app heap may not be recoverable without a restart
  620.     if (gpGWOffScreen)
  621.         DisposeGWorld (gpGWOffScreen);
  622.     gpGWOffScreen = NULL;
  623.     
  624.     hMenu = GetMenuHandle (kMenuFile);
  625.     DeleteMenu (kMenuFile);
  626.     DisposeMenu (hMenu);
  627.  
  628.     hMenu = GetMenuHandle (kMenuApple);
  629.     DeleteMenu (kMenuApple);
  630.     DisposeMenu (hMenu);
  631. }
  632.  
  633. // --------------------------------------------------------------------------
  634.  
  635. int main (void)
  636. {
  637.     if (SetUp ())
  638.         while (!gDone)
  639.             DoEvent ();
  640.     CleanUp ();
  641.     return 0;
  642. }
  643.  
  644.  
  645.